package lab;

import java.math.BigInteger;

/**
 * 原问题：一个数，最后一位是6，把这一位移到第一位，就是原来的数的3倍，问，这个数是几位数？
 * 拓展一下,最后一位是N
 * @author Think
 *
 */
public class Lab17 {

	public static void main(String[] args) throws Exception {
//		print1to9(6);
		print(6, 3);
		print2(6, 3);
	}
	
	public static void print(int endNum, int multiplier) throws Exception{
		BigInteger result = play(endNum, multiplier);
		System.out.println(String.format("%d结尾数：\t\t%s", endNum, result));
		System.out.println(String.format("%d结尾数 x %d：\t%s", endNum, multiplier, result.multiply(BigInteger.valueOf(multiplier))));
		System.out.println(String.format("%d结尾数长度：\t%s", endNum, result.toString().length()));
		System.out.println();
	}
	
	public static void print1to9(int multiplier) throws Exception{
		for(int i = 1; i < 10; i++){
			BigInteger result = play(i, multiplier);
			System.out.println(String.format("%d结尾数：\t\t%s", i, result));
			System.out.println(String.format("%d结尾数 x %d：\t%s", i, multiplier, result.multiply(BigInteger.valueOf(multiplier))));
			System.out.println(String.format("%d结尾数长度：\t%s", i, result.toString().length()));
			System.out.println();
		}
	}
	
	/**
	 * 思路：
	 * 以原题为例：
	 * ......6    ......6    .....86    .....86    ....586                 2068965517241379310344827586
	 *      x3 =>      x3 =>      x3 =>      x3 =>      x3 ......10年后 =>                           x3
	 * 6......    6.....8    6.....8    6....58    6....58                 6206896551724137931034482758
	 * 
	 * 逆向从高位往低位计算也可以，类似的实现。
	 * 
	 * @param endNum 末尾数 (0, 10)
	 * @param multiplier 倍数 (0, 10)
	 * @return
	 * @throws Exception
	 */
	public static BigInteger play(int endNum, int multiplier) throws Exception{
		if(!(0 < endNum && endNum < 10)){
			throw new Exception("endNum输入超出范围(0, 10)");
		}
		
		if(!(0 < multiplier && multiplier < 10)){
			throw new Exception("multiplier输入超出范围(0, 10)");
		}
		
		String num = "" + endNum;
		int multiplicand = endNum, carry = 0;
		
		int product;
		while((product = multiplicand * multiplier + carry) != endNum){
			multiplicand = product % 10;
			carry = product / 10;
			num = multiplicand + num;
		}
		
		return new BigInteger(num);
	}
	
	/**
	 * 设数为n位数，n~2位组成数x，位数为e，即该数为10 * x + e.
	 * 则将末尾数移至首位得数：e * 10^(n-1) + x
	 * 若倍速为m，按题意新数是原输3倍得：e * 10^(n-1) + x = m * (10 * x + e)
	 * 化简：x = (e * 10^(n-1) - e * m) / (10 * m - 1)
	 * 原题中m=3, e=6,代入上式即可得：x = (6 * 10^(n-1) - 18) / 29
	 * x和n都为正整数，从2开始依次递增代入n，若能得到正整数x则可以得答案
	 * 
	 * 这种方法没有play()简单，有一些大数计算，不过是另一种思路。
	 * 另外这里原数、新数、长度都是现成的，如果类似play()那样分开弄一个打印方法需要返回多个参数，比较麻烦，就干脆不分开了。
	 * 
	 * @param endNum 末尾数 (0, 10)
	 * @param multiplier 倍数 (0, 10)
	 */
	public static void print2(int endNum, int multiplier){
		BigInteger x, oldNum, newNum;
		BigInteger e = BigInteger.valueOf(endNum);
		BigInteger m = BigInteger.valueOf(multiplier);
		
		BigInteger t;
		int n = 2;
		
		while(true){
			//t = e * 10^(n-1)
			t = e.multiply(BigInteger.TEN.pow(n - 1));
			
			//x = (t - e * m) / (10 * m - 1)
			x = t.subtract(e.multiply(m)).divide(m.multiply(BigInteger.TEN).subtract(BigInteger.ONE));
			
			//oldNum = 10 * x + e
			oldNum = BigInteger.TEN.multiply(x).add(e);
			
			//newNum = t + x
			newNum = x.add(t);
			
			//若x计算的是整数，则oldNum * m = newNum成立
			if(newNum.equals(m.multiply(oldNum))){
				System.out.println(String.format("%d结尾数：\t\t%s", endNum, oldNum));
				System.out.println(String.format("%d结尾数 x %d：\t%s", endNum, multiplier, newNum));
				System.out.println(String.format("%d结尾数长度：\t%d", endNum, n));
				System.out.println();
				break;
			}
			n++;
		}
	}
}